const express = require('express');
const router = express.Router();

// 数据库配置文件
const db  = require('../Mysql/index')
const bcrypt = require('bcrypt');
// 密码加密
const jm = require('bcryptjs')
let sql;

const moment = require('moment');


// 查询订单
router.get('/Admin/getOrderList', (req, res) => {
    // 获取查询参数
    const data = req.query;
    const limit = parseInt(data.limit) || 10; // 每页条数，默认为10
    const page = parseInt(data.page) || 1; // 当前页，默认为第1页
    const offset = (page - 1) * limit; // 计算偏移量
    console.log('参数', req.query);

    // 检查是否提供了 shop_id 参数
    const shopUserId = data.shop_id;
    if (!shopUserId) {
        return res.cc("查询失败，缺少 shop_id 参数", 0);
    }

    // 构建SQL语句，连接 goods_type 表
    let sql = `
        SELECT o.*, g.name AS goods_name, s.name AS source_name
        FROM order_list o
        LEFT JOIN goods_type g ON o.shopType_id = g.id
        LEFT JOIN source s ON o.source = s.id
        WHERE o.shop_id = ?
    `;

    let conditions = [];
    let values = [shopUserId];

    // 如果传递了 startTime 和 endTime，添加时间范围查询
    if (data.startTime && data.endTime) {
        conditions.push(`o.createtime BETWEEN ? AND ?`);
        values.push(data.startTime, data.endTime);
    }

    // 遍历传递的参数，构建条件查询
    Object.keys(data).forEach(key => {
        // 过滤掉分页的参数，如 limit 和 page
        if (key !== 'limit' && key !== 'page' && key !== 'shop_id' && key !== 'startTime' && key !== 'endTime') {
            conditions.push(`o.${key} = ?`);
            values.push(data[key]);
        }
    });

    // 如果有查询条件，则加上 WHERE 子句
    if (conditions.length > 0) {
        sql += ` AND ` + conditions.join(' AND ');
    }

    // 添加分页查询
    sql += ` LIMIT ? OFFSET ?`;
    values.push(limit, offset);

    // 执行查询
    db.query(sql, values, (err, result) => {
        if (err) {
            console.log(err);
            return res.send({ err }); // 查询异常返回报错
        }
        // 查询总记录数以便返回分页的总页数
        let countSql = `
            SELECT COUNT(*) AS total
            FROM order_list o
            LEFT JOIN goods_type g ON o.shopType_id = g.id
            WHERE o.shop_id = ?
        `;
        if (data.startTime && data.endTime) {
            countSql += ` AND o.createtime BETWEEN ? AND ?`;
            values.push(data.startTime, data.endTime);
        }
        if (conditions.length > 0) {
            countSql += ` AND ` + conditions.join(' AND ');
        }
        // 查询总数
        db.query(countSql, values.slice(0, -2), (countErr, countResult) => { // 切掉分页的 limit 和 offset 值
            if (countErr) {
                console.log(countErr);
                return res.send({ err: countErr });
            }
            const total = countResult[0].total; // 总记录数
            const totalPages = Math.ceil(total / limit); // 计算总页数
            // 返回数据，包括订单数据、当前页码、每页条数、总记录数和总页数
            res.cc({
                data: result, // 当前页的数据
                page: page,
                limit: limit,
                count: total,
                totalPages: totalPages
            }, 1, "查询成功");
        });
    });
});

//添加订单
router.post('/Admin/addOrder', (req, res)=>{
    const data = req.body;
// 获取当前时间，格式化为 "YYYY-MM-DD HH:mm:ss"
    let time = moment().format('YYYY-MM-DD HH:mm:ss');
    // 计算利润
    let profit = parseFloat(data.money) - (parseFloat(data.addmoney)) * parseFloat(data.sum)
    const sql=`
        INSERT INTO order_list
        (shopType_id,age,sum,money,profit_age,shop_id,createtime,addmoney,source) 
        VALUES(?,?,?,?,?,?,?,?,?);`
    console.log('添加订单的数据',data,profit.toFixed(2),time)
    // 检查是否提供了 shop_id 参数
    const shopUserId = data.shop_id;
    if (!shopUserId) {
        return res.cc("添加失败，缺少 shop_id 参数");
    }
    // 解构赋值提交的参数
    let {shopType_id,age,sum,money,shop_id,addmoney,source} = data
    // 定义数据库数据
    let params = [
        shopType_id,
        age,
        sum,
        money,
        profit,
        shop_id,
        time,
        addmoney,
        source
    ]
    // 执行
    db.query(sql, params, (err, result) => {
        if (err) {
            console.error(err);
            return res.cc({ err }); // 查询异常返回报错
        }

        const resdata = result;
        // 如果查询成功但没有结果，返回空结果
        if (resdata.length === 0) {
            return res.cc("添加失败");
        } else {
            // 如果没有 limit，直接返回所有查询结果
            res.cc({
            }, 1, "添加成功");
        }
    });
})
//删除订单
router.post('/Admin/deleteOrder', (req, res) => {
    // 获取请求体中的参数
    const { id } = req.body;
    const data = req.body;
    const sql=`DELETE FROM order_list where id=?`

    db.query(sql,id, (err, result) => {
        if (err) {
            console.error(err);
            return res.send({ err }); // 查询异常返回报错
        }
        // 检查是否有行被删除
        if (result.affectedRows === 0) {
            return res.cc("删除失败!");
        }
        // 返回成功信息
        res.cc("",1,"删除成功!",);
    });
});
//更改订单
router.post('/Admin/updateOrder', (req, res) => {
    // 获取请求体中的参数
    const { id } = req.body; // 必须包含 id 和 shopUserId
    const updates = {};
    // 检查参数是否存在
    if (!id) {
        return res.cc("缺少必要的参数: id");
    }

    // 动态构建更新字段
    for (const key in req.body) {
        if (key !== 'id') { // 排除 id 和 shopUserId
            updates[key] = req.body[key];
        }
    }
    console.log('参数',updates)
    // 确保至少有一个字段需要更新
    if (Object.keys(updates).length === 0) {
        return res.cc("没有提供任何可更新的字段");
    }

    // 构建 SQL 更新语句
    const setClause = Object.keys(updates).map(key => `${key} = ?`).join(', ');
    const sql = `UPDATE order_list SET ${setClause} WHERE id = ?`;

    // 执行更新操作
    const sqlValues = [...Object.values(updates), id];

    db.query(sql, sqlValues, (err, result) => {
        if (err) {
            console.error(err);
            return res.send({ err }); // 查询异常返回报错
        }

        // 检查是否有行被更改
        if (result.affectedRows === 0) {
            return res.cc("未找到对应的订单或未进行任何修改");
        }
        // 返回成功信息
        res.cc("",1,"订单修改成功",);
    });
});

//查询订单来源列表
router.get('/Admin/getsourceList', (req, res) => {
    // 获取查询参数
    const data = req.query;
    const limit = parseInt(data.limit) || null; // 如果没有传limit，则设为null，表示查询全部
    const page = parseInt(data.page) || 1; // 当前页，默认为第1页
    const offset = limit ? (page - 1) * limit : 0; // 如果传了limit，则进行分页，否则offset为0

    // 检查是否提供了 shop_id 参数
    const shopUserId = data.shop_id;
    if (!shopUserId) {
        return res.cc("查询失败，缺少 shop_id 参数");
    }

    // 构建基本的 SQL 查询
    let sql = `
        SELECT *
        FROM source
        WHERE shop_id = ?
    `
    // 存储 SQL 查询条件和参数
    const conditions = [];
    const params = [shopUserId]; // 初始化参数数组
    // 动态添加额外的查询条件
    if (data.id) {
        conditions.push(`id = ?`);
        params.push(data.id); // 如果传了 type，添加条件
    }
    // 如果有额外条件，合并到 SQL 查询中
    if (conditions.length > 0) {
        sql += ' AND ' + conditions.join(' AND ');
    }

    // 添加分页限制，如果有 limit 和 page 参数
    if (limit) {
        sql += ' LIMIT ? OFFSET ?';
        params.push(limit, offset); // 添加 limit 和 offset 到参数数组
    }

    // 执行查询
    db.query(sql, params, (err, result) => {
        if (err) {
            console.error(err);
            return res.send({ err }); // 查询异常返回报错
        }

        const resdata = result;
        // 如果查询成功但没有结果，返回空结果
        if (resdata.length === 0) {
            return res.cc("没有找到相关数据");
        }

        // 如果有分页查询，查询总记录数以便返回分页的总页数
        if (limit) {
            let countSql = `
                SELECT COUNT(*) AS total 
                FROM source 
                WHERE shop_id = ?
            `;

            // 查询总数
            db.query(countSql, [shopUserId], (countErr, countResult) => {
                if (countErr) {
                    console.error(countErr);
                    return res.send({ err: countErr });
                }

                const total = countResult[0].total; // 总记录数
                const totalPages = Math.ceil(total / limit); // 计算总页数

                // 返回数据，包括商品分类数据、当前页码、每页条数、总记录数和总页数
                res.cc({
                    data: result, // 当前页的数据
                    currentPage: page,
                    pageSize: limit,
                    count: total,
                    totalPages: totalPages
                }, 1, "查询成功");
            });
        } else {
            // 如果没有 limit，直接返回所有查询结果
            res.cc({
                data: result
            }, 1, "查询成功");
        }
    });
});

//查询店铺所有销售额 利润 成交数
router.get('/Admin/getMoney', (req, res) => {
    // 获取查询参数
    const data = req.query;
    let {shop_id} = req.query;
    if (!shop_id) {
        return res.cc("查询失败，缺少 shop_id 参数");
    }

    // 构建基本的 SQL 查询
    let sqlCount = `
        SELECT count(id) AS total,sum(age) AS age,sum(profit_age) AS profit_age , avg(age - profit_age) as data
        FROM order_list
        WHERE shop_id = ?
    `
    // 执行查询
    db.query(sqlCount, shop_id, (err, result) => {
        if (err) {
            console.error(err);
            return res.send({ err }); // 查询异常返回报错
        }
        //总订单数
        const resdata = result;
        // 如果查询成功但没有结果，返回空结果
        if (resdata.length === 0) {
            return res.cc("没有找到相关数据");
        }
        let echartsSql = `SELECT sum(o.age) as value,e.name
        FROM order_list o
        LEFT JOIN goods_type e ON e.id = o.shopType_id
        LEFT JOIN goods_title t ON t.id = e.type
        GROUP BY e.name`
        db.query(echartsSql, (err, resData) => {
            if (err) {
                console.error(err);
                return res.send({ err }); // 查询异常返回报错
            }
            // 如果查询成功但没有结果，返回空结果
            if (resData.length === 0) {
                return res.cc("没有找到相关数据");
            }
            // 如果没有 limit，直接返回所有查询结果
            res.cc({
                data: {Data:resdata,echartsData:resData}
            }, 1, "查询成功");

        });

    });
});


module.exports = router;
